home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / FPSE_src / system / amiga / plugin / gpu / gpumain.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-01  |  13.4 KB  |  503 lines
  1. #include "gpulocal.h"
  2.  
  3. UINT8 primsizeT[256] =
  4. {
  5.      0,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* 00 */
  6.      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* 10 */
  7.      4,4,4,4,7,7,7,7,5,5,5,5,9,9,9,9,   /* 20 */
  8.      6,6,6,6,9,9,9,9,8,8,8,8,12,12,12,12,/* 30 */
  9.      3,3,3,3,0,0,0,0,5,5,5,5,6,6,6,6,   /* 40 */
  10.      4,4,4,4,0,0,0,0,7,7,7,7,9,9,9,9,   /* 50 */
  11.      3,3,3,3,4,4,4,4,2,2,2,2,0,0,0,0,   /* 60 */
  12.      2,2,2,2,3,3,3,3,2,2,2,2,3,3,3,3,   /* 70 */
  13.      4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* 80 */
  14.      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* 90 */
  15.      3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* a0 */
  16.      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* b0 */
  17.      3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* c0 */
  18.      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* d0 */
  19.      0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,   /* e0 */
  20.      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,   /* f0 */
  21. };
  22.  
  23. static int gpu_unknown(UINT32 *prim);
  24. static int gpu_01(UINT32 *prim);
  25. static int gpu_LoadImage(UINT16 *sp);
  26. static int gpu_MoveImage(UINT16 *sp);
  27. static int gpu_StoreImage(UINT16 *sp);
  28. static int gpu_e1(UINT32 *prim);
  29. static int gpu_e2(UINT32 *prim);
  30. static int gpu_e3(UINT32 *prim);
  31. static int gpu_e4(UINT32 *prim);
  32. static int gpu_e5(UINT32 *prim);
  33. static int gpu_e6(UINT32 *prim);
  34.  
  35. int (*primfunc[256])() = {
  36.      /* 00 */
  37.      gpu_unknown,gpu_01,gpu_fill,gpu_unknown,
  38.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  39.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  40.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  41.      /* 10 */
  42.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  43.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  44.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  45.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  46.      /* 20 */
  47.      gpu_polyF3,gpu_polyF3,gpu_polyF3,gpu_polyF3,
  48.      gpu_polyFT3,gpu_polyFT3,gpu_polyFT3,gpu_polyFT3,
  49.      gpu_polyF4,gpu_polyF4,gpu_polyF4,gpu_polyF4,
  50.      gpu_polyFT4,gpu_polyFT4,gpu_polyFT4,gpu_polyFT4,
  51.      /* 30 */
  52.      gpu_polyG3,gpu_polyG3,gpu_polyG3,gpu_polyG3,
  53.      gpu_polyGT3,gpu_polyGT3,gpu_polyGT3,gpu_polyGT3,
  54.      gpu_polyG4,gpu_polyG4,gpu_polyG4,gpu_polyG4,
  55.      gpu_polyGT4,gpu_polyGT4,gpu_polyGT4,gpu_polyGT4,
  56.      /* 40 */
  57.      gpu_lineF2,gpu_lineF2,gpu_lineF2,gpu_lineF2,
  58.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  59.      gpu_lineF,gpu_lineF,gpu_lineF,gpu_lineF,
  60.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  61.      /* 50 */
  62.      gpu_lineG2,gpu_lineG2,gpu_lineG2,gpu_lineG2,
  63.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  64.      gpu_lineG,gpu_lineG,gpu_lineG,gpu_lineG,
  65.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  66.      /* 60 */
  67.      gpu_tile,gpu_tile,gpu_tile,gpu_tile,
  68.      gpu_sprt,gpu_sprt,gpu_sprt,gpu_sprt,
  69.      gpu_tile1,gpu_tile1,gpu_tile1,gpu_tile1,
  70.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  71.      /* 70 */
  72.      gpu_tile8,gpu_tile8,gpu_tile8,gpu_tile8,
  73.      gpu_sprt8,gpu_sprt8,gpu_sprt8,gpu_sprt8,
  74.      gpu_tile16,gpu_tile16,gpu_tile16,gpu_tile16,
  75.      gpu_sprt16,gpu_sprt16,gpu_sprt16,gpu_sprt16,
  76.      /* 80 */
  77.      gpu_MoveImage,gpu_unknown,gpu_unknown,gpu_unknown,
  78.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  79.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  80.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  81.      /* 90 */
  82.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  83.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  84.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  85.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  86.      /* a0 */
  87.      gpu_LoadImage,gpu_unknown,gpu_unknown,gpu_unknown,
  88.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  89.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  90.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  91.      /* b0 */
  92.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  93.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  94.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  95.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  96.      /* c0 */
  97.      gpu_StoreImage,gpu_unknown,gpu_unknown,gpu_unknown,
  98.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  99.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  100.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  101.      /* d0 */
  102.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  103.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  104.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  105.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  106.      /* e0 */
  107.      gpu_unknown,gpu_e1,gpu_e2,gpu_e3,
  108.      gpu_e4,gpu_e5,gpu_e6,gpu_unknown,
  109.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  110.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  111.      /* f0 */
  112.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  113.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  114.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  115.      gpu_unknown,gpu_unknown,gpu_unknown,gpu_unknown,
  116. };
  117.  
  118. static short clutflg[0x8000/16];
  119. static long tpageflg;
  120.  
  121. GPU_Type  gpu;
  122. INT16    *vram;
  123. /*
  124.      gpu status
  125.     0 - 10 : draw mode (e0 prim )
  126.     11,12: mask mode
  127.     12-15: ??
  128.     16 - 22: disp mode
  129.      23: Display (1=off)
  130.     24-25: ??
  131.      26: GPU ready (1=ready)
  132.      27: storeimage ready (1=ready)
  133.      28: command ready (1=ready)
  134.      29-30: DMA mode
  135.     31: in interlace mode, 1:odd 0:even
  136. */
  137.  
  138. void GPU_Update(void)
  139. {
  140. /* interlace odd/even */
  141.     gpu.status^=0x80000000;
  142.  
  143. /* Update Image */
  144.     if (toUpdate)
  145.     {
  146.         screen_update();
  147.         toUpdate = 0;
  148.     }
  149. }
  150.  
  151. UINT32 GP1_Read(void)
  152. {
  153.      return (gpu.status | 0x1c000000) & ~0x00480000;
  154.      // isinter‚Æheight=480 ‚ðoff ‚±‚ꂪ‚ ‚é‚ÆinterlaseŽž‚Éwait‚·‚é‚Ì‚Å
  155.      /* GPU_Idle | GPU_cmd_ready | img ready */
  156.       //|0x800;
  157.      /* nazo */
  158. }
  159.  
  160. UINT32 GP0_Read(void)
  161. {
  162.      if (inTrans==VRAM2MEM) {
  163.           int tmp;
  164.           tmp = pvram[px];
  165.           if (++px>=x_end) {
  166.                px = x_start;
  167.                pvram += 1024;
  168.                if (++py>=y_end) inTrans=0;
  169.           }
  170.           tmp |= pvram[px]<<16;
  171.           if (++px>=x_end) {
  172.                px = x_start;
  173.                pvram +=1024;
  174.                if (++py>=y_end) inTrans=0;
  175.           }
  176.           gpu.retval = tmp;
  177.      }
  178.      return gpu.retval;
  179. }
  180.  
  181. void GP0_Write(UINT32 data)
  182. {
  183.      if (inTrans==MEM2VRAM) {
  184.           pvram[px]=data;
  185.           if (++px>=x_end) {
  186.                px = x_start;
  187.                pvram += 1024;
  188.                if (++py>=y_end) inTrans=0;
  189.           }
  190.           if (inTrans) {
  191.                pvram[px]=data>>16;
  192.                if (++px>=x_end) {
  193.                     px = x_start;
  194.                     pvram += 1024;
  195.                     if (++py>=y_end) inTrans=0;
  196.                }
  197.           }
  198.           if (inTrans==0) {
  199.                vramchange(x_start,y_start,x_end,y_end);
  200.           }
  201.           return;
  202.      }
  203.      if (gpu.primptr) {
  204.           gpu.primdata[gpu.primptr++] = data;
  205.           if (gpu.primptr == gpu.primsize) {
  206.                         gpu.primdata[gpu.primptr] = 0x55555555;
  207.                gpu.primptr = gpu.primsize = 0;
  208.                do_prim(gpu.primdata);
  209.           }
  210.      } else {
  211.           int primsize=primsizeT[data>>24];
  212.           gpu.primdata[0] = data;
  213.           switch(primsize) {
  214.           case 0:
  215.                printf("unknown prim:%08x\n",(int)data);
  216.                break;
  217.           case 1:
  218.                do_prim(gpu.primdata);
  219.                break;
  220.           default:
  221.                gpu.primsize = primsize;
  222.                gpu.primptr = 1;
  223.                break;
  224.           }
  225.      }
  226. }
  227.  
  228. void GP1_Write(UINT32 code)
  229. {
  230.      switch(code>>24) {
  231.      case 0x00:     /* All Reset */
  232.           gpu.status = 0x14802000;
  233.           /* com ready | GPU ready | display off 
  234.           256x240, NTSC, 15bit, non-interlace,
  235.           tpage = 0, dither off, can't draw to display area, mask off
  236.           */
  237.           gpu.disp.w = gpu.screen.w = 256;
  238.                 gpu.disp.h = gpu.screen.h = 240;
  239.                 win_resize(256,240);
  240.           break;
  241.      case 0x01:     /* Command Reset */
  242.           gpu.primptr = gpu.primsize = 0;
  243.           break;
  244.      case 0x02:     /* IRQ Reset */
  245.           break;
  246.      case 0x03:     /* Display Mask */
  247.           /* bit 1 to status bit 23 */
  248.           gpu.status = (gpu.status & ~(1<<23)) | ((code&1)<<23);
  249.           break;
  250.      case 0x04:     /* DMA mode */
  251.           /* bit 0,1 to status bit 29,30 */
  252.           gpu.status = (gpu.status & ~(3<<29)) | ((code&3)<<29);
  253.  
  254.                 switch (code) {
  255.                 case 0:
  256.                     inTrans = 0;
  257.                     break;
  258.                 case 2:
  259.                     inTrans = MEM2VRAM;
  260.                     break;
  261.                 case 3:
  262.                     inTrans = VRAM2MEM;
  263.                     break;
  264.                 }
  265.  
  266.           break;
  267.      case 0x05:     /* disp offset */
  268.           gpu.disp.x = code & 0x3ff;
  269.           gpu.disp.y = (code>>10) & 0x3ff;
  270.           break;
  271.      case 0x06: {   /* H start/end */
  272.           int s,e;
  273.           s = code&0xfff;
  274.           e = (code>>12)&0xfff;
  275.           gpu.screen.x = (s - 608)/10;
  276.           gpu.screen.w = (e-s)/10;
  277.           }
  278.           break;
  279.      case 0x07: {   /* V start/end */
  280.           int s,e;
  281.           s = code&0x3ff;
  282.           e = (code>>10)&0x3ff;
  283.           gpu.screen.y = s - PAL?19:16;
  284.           gpu.screen.h = e-s;
  285.           }
  286.           break;
  287.      case 0x08:     /* display mode */
  288.           /* bit 0..5 to status bit 17..22  */
  289.           /* bit    6 to status bit 16      */
  290.           gpu.status = (gpu.status &~0x7f0000) | ((code&0x3f)<<17) | ((code&0x40)<<(16-6));
  291.           { static int dispw[] = {256,320,512,640};
  292.           if (code&0x40) gpu.disp.w = 368;
  293.           else gpu.disp.w = dispw[code&3];
  294.           }
  295.           gpu.disp.h = (code&4)?480:240;
  296.                 win_resize(gpu.disp.w,gpu.disp.h);
  297.                 toUpdate = 1;
  298.           break;
  299.      case 0x10:     /* GPU Info */
  300.           switch(code&0xffffff) {
  301.           case 3:
  302.           case 4:
  303.           case 5:
  304.                gpu.retval = gpu.info[code&0xffffff];
  305.                break;
  306.           case 7:
  307.                gpu.retval = 2; /* version */
  308.                break;
  309.           }
  310.           break;
  311.      default:
  312.           printf("unknown %x\n",(int)code);
  313.           break;
  314.      }
  315. }
  316.  
  317. /*
  318.      return true if tpage changed
  319.      and clear changed flag
  320.  
  321.      check 1page if  4bit texture
  322.      check 2page if  8bit texture
  323.      check 4page if 15bit texture
  324. */
  325. int tpage_changed(int tpage)
  326. {
  327.      int changed,mask;
  328.      static int mask0[] = {1,3,15};
  329.      /* mode = 0:1page 1:2page 3:4page */
  330.  
  331.      mask = mask0[(tpage>>7)&3];
  332.      tpage&=31;
  333.      changed = tpageflg &   (mask<<tpage);
  334.      if (changed)  tpageflg &= ~(mask<<tpage);
  335.      return changed;
  336. }
  337.  
  338. /*
  339.      return true if clut changed
  340.      and clear changed flag
  341. */
  342. int clut_changed(int clut)
  343. {
  344.      int changed;
  345.      changed = clutflg[clut/16] &   (1<<(clut&16));
  346.      if (changed)  clutflg[clut/16] &= ~(1<<(clut&16));
  347.      return changed;
  348. }
  349.  
  350. void vramchange(int x0,int y0,int x1,int y1)
  351. {
  352.      int x,y;
  353.      for(y=y0 ;y<y1; y++) {
  354.           for(x=x0/16; x<=(x1-1)/16; x++)
  355.           //   clutflg[x+y*64]=1;
  356.                clutflg[(x+y*64)/16] |= 1<<(x&16);
  357.      }
  358.      for(y=y0/256; y<=(y1-1)/256; y++) {
  359.           for(x=x0/64; x<=(x1-1)/64; x++)
  360.           //   tpageflg[x+y*16]=1;
  361.                tpageflg |= 1<<(x+y*16);
  362.      }
  363.     toUpdate = 1;
  364. }
  365.  
  366. static int gpu_unknown(UINT32 *prim)
  367. {
  368.     return 1;
  369. }
  370.  
  371. static int gpu_01(UINT32 *prim)
  372. {
  373.     return 1;
  374. }
  375.  
  376. static int gpu_LoadImage(UINT16 *sp)
  377. {
  378.      /* LoadImage */
  379.      inTrans = MEM2VRAM;
  380. #ifdef MSB_FIRST
  381.      px = x_start = sp[3];
  382.      py = y_start = sp[2];
  383.      x_end = x_start + sp[5];
  384.      y_end = y_start + sp[4];
  385. #else
  386.      px = x_start = sp[2];
  387.      py = y_start = sp[3];
  388.      x_end = x_start + sp[4];
  389.      y_end = y_start + sp[5];
  390. #endif
  391.      pvram = &vram[py*1024];
  392.  
  393.     return 3;
  394. }
  395.  
  396. static int gpu_MoveImage(UINT16 *sp)
  397. {
  398.      int x0,y0,x1,y1,w,h;
  399. #ifdef MSB_FIRST
  400.      x0 = sp[3]&1023;
  401.      y0 = sp[2]& 511;
  402.      x1 = sp[5]&1023;
  403.      y1 = sp[4]& 511;
  404.      w  = sp[7]&1023;
  405.      h  = sp[6]& 511;
  406. #else
  407.      x0 = sp[2]&1023;
  408.      y0 = sp[3]& 511;
  409.      x1 = sp[4]&1023;
  410.      y1 = sp[5]& 511;
  411.      w  = sp[6]&1023;
  412.      h  = sp[7]& 511;
  413. #endif
  414.      move(x0,y0,x1,y1,w,h);
  415.      vramchange(x1,y1,x1+w,y1+h);
  416.  
  417.     return 4;
  418. }
  419.  
  420. static int gpu_StoreImage(UINT16 *sp)
  421. {
  422. /* StoreImage */
  423.     inTrans = VRAM2MEM;
  424. #ifdef MSB_FIRST
  425.     px = x_start = sp[3];
  426.     py = y_start = sp[2];
  427.     x_end = x_start + sp[5];
  428.     y_end = y_start + sp[4];
  429. #else
  430.     px = x_start = sp[2];
  431.     py = y_start = sp[3];
  432.     x_end = x_start + sp[4];
  433.     y_end = y_start + sp[5];
  434. #endif
  435.     pvram = &vram[py*1024];
  436.  
  437.     return 3;
  438. }
  439.  
  440. static int gpu_e1(UINT32 *prim)
  441. {
  442.     UINT32 code = prim[0];
  443. /* bit 0..10 to status bit 0..10 */
  444.  
  445.     gpu.status = ( gpu.status &~0x7ff) | (code&0x7ff);
  446.     gpu.tpage = code & 0x7ff;
  447.  
  448.     return 1;
  449. }
  450.  
  451. static int gpu_e2(UINT32 *prim)
  452. {
  453.     UINT32 code = prim[0];
  454.  
  455.     gpu.texwindow.w = ((code&31))*8;
  456.     gpu.texwindow.h = ((code>>5)&31)*8;
  457.     gpu.texwindow.x = 256-((code>>10)&31)*8;
  458.     gpu.texwindow.y = 256-((code>>15)&31)*8;
  459.  
  460.     return 1;
  461. }
  462.  
  463. static int gpu_e3(UINT32 *prim)
  464. {
  465.     UINT32 code = prim[0];
  466.  
  467.     gpu.info[3] = code&0xffffff;
  468.     gpu.clip_min.x = code&0x3ff;
  469.     gpu.clip_min.y = (code>>10)&0x1ff;
  470.  
  471.     return 1;
  472. }
  473.  
  474. static int gpu_e4(UINT32 *prim)
  475. {
  476.     UINT32 code = prim[0];
  477.  
  478.     gpu.info[4] = code&0xffffff;
  479.     gpu.clip_max.x = code&0x3ff;
  480.     gpu.clip_max.y = (code>>10)&0x1ff;
  481.  
  482.     return 1;
  483. }
  484.  
  485. static int gpu_e5(UINT32 *prim)
  486. {
  487.     UINT32 code = prim[0];
  488.  
  489.     gpu.info[5] = code&0xffffff;
  490.     gpu.drawoffset.x = ((int)code<<(32-11))>>(32-11);
  491.     gpu.drawoffset.y = ((int)code<<(32-22))>>(32-11);
  492.  
  493.     return 1;
  494. }
  495.  
  496. static int gpu_e6(UINT32 *prim)
  497. {
  498.     UINT32 code = prim[0];
  499. /* bit 0,1 to status bit 11,12 */
  500.     gpu.status = (gpu.status & ~(3<<11)) | ((code&3)<<11);
  501.  
  502.     return 1;
  503. }